﻿namespace UglyToad.PdfPig.Fonts.Encodings
{
    /// <summary>
    /// Zapf Dingbats encoding.
    /// </summary>
    public sealed class ZapfDingbatsEncoding : Encoding
    {
        /// <summary>
        /// EncodingTable for ZapfDingbats
        /// PDF Spec 1.7 Page 1016 https://opensource.adobe.com/dc-acrobat-sdk-docs/pdfstandards/pdfreference1.7old.pdf#page1016
        /// Note spec has code values are octal (base 8) with leading zero (supported in 'C' and 'Java') but not by C#
        /// Code values are already converted to base 10 prior to compile. Original octal values in comments on each line.
        /// </summary>
        private static readonly (int, string)[] EncodingTable = {
            ( 32, "space"),                     // for char ' ' using  32 as base10 equivalent (for C# source). Spec has 040 octal.               ( 32,"space")  <=> (040, "space"),
            ( 33, "a1"),                        // for char '!' using  33 as base10 equivalent (for C# source). Spec has 041 octal.               ( 33,"a1")     <=> (041, "a1")   ,
            ( 34, "a2"),                        // for char '"' using  34 as base10 equivalent (for C# source). Spec has 042 octal.               ( 34,"a2")     <=> (042, "a2")   ,
            ( 35, "a202"),                      // for char '#' using  35 as base10 equivalent (for C# source). Spec has 043 octal.               ( 35,"a202")   <=> (043, "a202") ,
            ( 36, "a3"),                        // for char '$' using  36 as base10 equivalent (for C# source). Spec has 044 octal.               ( 36,"a3")     <=> (044, "a3")   ,
            ( 37, "a4"),                        // for char '%' using  37 as base10 equivalent (for C# source). Spec has 045 octal.               ( 37,"a4")     <=> (045, "a4")   ,
            ( 38, "a5"),                        // for char '&' using  38 as base10 equivalent (for C# source). Spec has 046 octal.               ( 38,"a5")     <=> (046, "a5")   ,
            ( 39, "a119"),                      // for char ''' using  39 as base10 equivalent (for C# source). Spec has 047 octal.               ( 39,"a119")   <=> (047, "a119") ,
            ( 40, "a118"),                      // for char '(' using  40 as base10 equivalent (for C# source). Spec has 050 octal.               ( 40,"a118")   <=> (050, "a118") ,
            ( 41, "a117"),                      // for char ')' using  41 as base10 equivalent (for C# source). Spec has 051 octal.               ( 41,"a117")   <=> (051, "a117") ,
            ( 42, "a11"),                       // for char '*' using  42 as base10 equivalent (for C# source). Spec has 052 octal.               ( 42,"a11")    <=> (052, "a11")  ,
            ( 43, "a12"),                       // for char '+' using  43 as base10 equivalent (for C# source). Spec has 053 octal.               ( 43,"a12")    <=> (053, "a12")  ,
            ( 44, "a13"),                       // for char ',' using  44 as base10 equivalent (for C# source). Spec has 054 octal.               ( 44,"a13")    <=> (054, "a13")  ,
            ( 45, "a14"),                       // for char '-' using  45 as base10 equivalent (for C# source). Spec has 055 octal.               ( 45,"a14")    <=> (055, "a14")  ,
            ( 46, "a15"),                       // for char '.' using  46 as base10 equivalent (for C# source). Spec has 056 octal.               ( 46,"a15")    <=> (056, "a15")  ,
            ( 47, "a16"),                       // for char '/' using  47 as base10 equivalent (for C# source). Spec has 057 octal.               ( 47,"a16")    <=> (057, "a16")  ,
            ( 48, "a105"),                      // for char '0' using  48 as base10 equivalent (for C# source). Spec has 060 octal.               ( 48,"a105")   <=> (060, "a105") ,
            ( 49, "a17"),                       // for char '1' using  49 as base10 equivalent (for C# source). Spec has 061 octal.               ( 49,"a17")    <=> (061, "a17")  ,
            ( 50, "a18"),                       // for char '2' using  50 as base10 equivalent (for C# source). Spec has 062 octal.               ( 50,"a18")    <=> (062, "a18")  ,
            ( 51, "a19"),                       // for char '3' using  51 as base10 equivalent (for C# source). Spec has 063 octal.               ( 51,"a19")    <=> (063, "a19")  ,
            ( 52, "a20"),                       // for char '4' using  52 as base10 equivalent (for C# source). Spec has 064 octal.               ( 52,"a20")    <=> (064, "a20")  ,
            ( 53, "a21"),                       // for char '5' using  53 as base10 equivalent (for C# source). Spec has 065 octal.               ( 53,"a21")    <=> (065, "a21")  ,
            ( 54, "a22"),                       // for char '6' using  54 as base10 equivalent (for C# source). Spec has 066 octal.               ( 54,"a22")    <=> (066, "a22")  ,
            ( 55, "a23"),                       // for char '7' using  55 as base10 equivalent (for C# source). Spec has 067 octal.               ( 55,"a23")    <=> (067, "a23")  ,
            ( 56, "a24"),                       // for char '8' using  56 as base10 equivalent (for C# source). Spec has 070 octal.               ( 56,"a24")    <=> (070, "a24")  ,
            ( 57, "a25"),                       // for char '9' using  57 as base10 equivalent (for C# source). Spec has 071 octal.               ( 57,"a25")    <=> (071, "a25")  ,
            ( 58, "a26"),                       // for char ':' using  58 as base10 equivalent (for C# source). Spec has 072 octal.               ( 58,"a26")    <=> (072, "a26")  ,
            ( 59, "a27"),                       // for char ';' using  59 as base10 equivalent (for C# source). Spec has 073 octal.               ( 59,"a27")    <=> (073, "a27")  ,
            ( 60, "a28"),                       // for char '<' using  60 as base10 equivalent (for C# source). Spec has 074 octal.               ( 60,"a28")    <=> (074, "a28")  ,
            ( 61, "a6"),                        // for char '=' using  61 as base10 equivalent (for C# source). Spec has 075 octal.               ( 61,"a6")     <=> (075, "a6")   ,
            ( 62, "a7"),                        // for char '>' using  62 as base10 equivalent (for C# source). Spec has 076 octal.               ( 62,"a7")     <=> (076, "a7")   ,
            ( 63, "a8"),                        // for char '?' using  63 as base10 equivalent (for C# source). Spec has 077 octal.               ( 63,"a8")     <=> (077, "a8")   ,
            ( 64, "a9"),                        // for char '@' using  64 as base10 equivalent (for C# source). Spec has 0100 octal.              ( 64,"a9")     <=> (0100, "a9")  ,
            ( 65, "a10"),                       // for char 'A' using  65 as base10 equivalent (for C# source). Spec has 0101 octal.              ( 65,"a10")    <=> (0101, "a10") ,
            ( 66, "a29"),                       // for char 'B' using  66 as base10 equivalent (for C# source). Spec has 0102 octal.              ( 66,"a29")    <=> (0102, "a29") ,
            ( 67, "a30"),                       // for char 'C' using  67 as base10 equivalent (for C# source). Spec has 0103 octal.              ( 67,"a30")    <=> (0103, "a30") ,
            ( 68, "a31"),                       // for char 'D' using  68 as base10 equivalent (for C# source). Spec has 0104 octal.              ( 68,"a31")    <=> (0104, "a31") ,
            ( 69, "a32"),                       // for char 'E' using  69 as base10 equivalent (for C# source). Spec has 0105 octal.              ( 69,"a32")    <=> (0105, "a32") ,
            ( 70, "a33"),                       // for char 'F' using  70 as base10 equivalent (for C# source). Spec has 0106 octal.              ( 70,"a33")    <=> (0106, "a33") ,
            ( 71, "a34"),                       // for char 'G' using  71 as base10 equivalent (for C# source). Spec has 0107 octal.              ( 71,"a34")    <=> (0107, "a34") ,
            ( 72, "a35"),                       // for char 'H' using  72 as base10 equivalent (for C# source). Spec has 0110 octal.              ( 72,"a35")    <=> (0110, "a35") ,
            ( 73, "a36"),                       // for char 'I' using  73 as base10 equivalent (for C# source). Spec has 0111 octal.              ( 73,"a36")    <=> (0111, "a36") ,
            ( 74, "a37"),                       // for char 'J' using  74 as base10 equivalent (for C# source). Spec has 0112 octal.              ( 74,"a37")    <=> (0112, "a37") ,
            ( 75, "a38"),                       // for char 'K' using  75 as base10 equivalent (for C# source). Spec has 0113 octal.              ( 75,"a38")    <=> (0113, "a38") ,
            ( 76, "a39"),                       // for char 'L' using  76 as base10 equivalent (for C# source). Spec has 0114 octal.              ( 76,"a39")    <=> (0114, "a39") ,
            ( 77, "a40"),                       // for char 'M' using  77 as base10 equivalent (for C# source). Spec has 0115 octal.              ( 77,"a40")    <=> (0115, "a40") ,
            ( 78, "a41"),                       // for char 'N' using  78 as base10 equivalent (for C# source). Spec has 0116 octal.              ( 78,"a41")    <=> (0116, "a41") ,
            ( 79, "a42"),                       // for char 'O' using  79 as base10 equivalent (for C# source). Spec has 0117 octal.              ( 79,"a42")    <=> (0117, "a42") ,
            ( 80, "a43"),                       // for char 'P' using  80 as base10 equivalent (for C# source). Spec has 0120 octal.              ( 80,"a43")    <=> (0120, "a43") ,
            ( 81, "a44"),                       // for char 'Q' using  81 as base10 equivalent (for C# source). Spec has 0121 octal.              ( 81,"a44")    <=> (0121, "a44") ,
            ( 82, "a45"),                       // for char 'R' using  82 as base10 equivalent (for C# source). Spec has 0122 octal.              ( 82,"a45")    <=> (0122, "a45") ,
            ( 83, "a46"),                       // for char 'S' using  83 as base10 equivalent (for C# source). Spec has 0123 octal.              ( 83,"a46")    <=> (0123, "a46") ,
            ( 84, "a47"),                       // for char 'T' using  84 as base10 equivalent (for C# source). Spec has 0124 octal.              ( 84,"a47")    <=> (0124, "a47") ,
            ( 85, "a48"),                       // for char 'U' using  85 as base10 equivalent (for C# source). Spec has 0125 octal.              ( 85,"a48")    <=> (0125, "a48") ,
            ( 86, "a49"),                       // for char 'V' using  86 as base10 equivalent (for C# source). Spec has 0126 octal.              ( 86,"a49")    <=> (0126, "a49") ,
            ( 87, "a50"),                       // for char 'W' using  87 as base10 equivalent (for C# source). Spec has 0127 octal.              ( 87,"a50")    <=> (0127, "a50") ,
            ( 88, "a51"),                       // for char 'X' using  88 as base10 equivalent (for C# source). Spec has 0130 octal.              ( 88,"a51")    <=> (0130, "a51") ,
            ( 89, "a52"),                       // for char 'Y' using  89 as base10 equivalent (for C# source). Spec has 0131 octal.              ( 89,"a52")    <=> (0131, "a52") ,
            ( 90, "a53"),                       // for char 'Z' using  90 as base10 equivalent (for C# source). Spec has 0132 octal.              ( 90,"a53")    <=> (0132, "a53") ,
            ( 91, "a54"),                       // for char '[' using  91 as base10 equivalent (for C# source). Spec has 0133 octal.              ( 91,"a54")    <=> (0133, "a54") ,
            ( 92, "a55"),                       // for char '\' using  92 as base10 equivalent (for C# source). Spec has 0134 octal.              ( 92,"a55")    <=> (0134, "a55") ,
            ( 93, "a56"),                       // for char ']' using  93 as base10 equivalent (for C# source). Spec has 0135 octal.              ( 93,"a56")    <=> (0135, "a56") ,
            ( 94, "a57"),                       // for char '^' using  94 as base10 equivalent (for C# source). Spec has 0136 octal.              ( 94,"a57")    <=> (0136, "a57") ,
            ( 95, "a58"),                       // for char '_' using  95 as base10 equivalent (for C# source). Spec has 0137 octal.              ( 95,"a58")    <=> (0137, "a58") ,
            ( 96, "a59"),                       // for char '`' using  96 as base10 equivalent (for C# source). Spec has 0140 octal.              ( 96,"a59")    <=> (0140, "a59") ,
            ( 97, "a60"),                       // for char 'a' using  97 as base10 equivalent (for C# source). Spec has 0141 octal.              ( 97,"a60")    <=> (0141, "a60") ,
            ( 98, "a61"),                       // for char 'b' using  98 as base10 equivalent (for C# source). Spec has 0142 octal.              ( 98,"a61")    <=> (0142, "a61") ,
            ( 99, "a62"),                       // for char 'c' using  99 as base10 equivalent (for C# source). Spec has 0143 octal.              ( 99,"a62")    <=> (0143, "a62") ,
            (100, "a63"),                       // for char 'd' using 100 as base10 equivalent (for C# source). Spec has 0144 octal.              (100,"a63")    <=> (0144, "a63") ,
            (101, "a64"),                       // for char 'e' using 101 as base10 equivalent (for C# source). Spec has 0145 octal.              (101,"a64")    <=> (0145, "a64") ,
            (102, "a65"),                       // for char 'f' using 102 as base10 equivalent (for C# source). Spec has 0146 octal.              (102,"a65")    <=> (0146, "a65") ,
            (103, "a66"),                       // for char 'g' using 103 as base10 equivalent (for C# source). Spec has 0147 octal.              (103,"a66")    <=> (0147, "a66") ,
            (104, "a67"),                       // for char 'h' using 104 as base10 equivalent (for C# source). Spec has 0150 octal.              (104,"a67")    <=> (0150, "a67") ,
            (105, "a68"),                       // for char 'i' using 105 as base10 equivalent (for C# source). Spec has 0151 octal.              (105,"a68")    <=> (0151, "a68") ,
            (106, "a69"),                       // for char 'j' using 106 as base10 equivalent (for C# source). Spec has 0152 octal.              (106,"a69")    <=> (0152, "a69") ,
            (107, "a70"),                       // for char 'k' using 107 as base10 equivalent (for C# source). Spec has 0153 octal.              (107,"a70")    <=> (0153, "a70") ,
            (108, "a71"),                       // for char 'l' using 108 as base10 equivalent (for C# source). Spec has 0154 octal.              (108,"a71")    <=> (0154, "a71") ,
            (109, "a72"),                       // for char 'm' using 109 as base10 equivalent (for C# source). Spec has 0155 octal.              (109,"a72")    <=> (0155, "a72") ,
            (110, "a73"),                       // for char 'n' using 110 as base10 equivalent (for C# source). Spec has 0156 octal.              (110,"a73")    <=> (0156, "a73") ,
            (111, "a74"),                       // for char 'o' using 111 as base10 equivalent (for C# source). Spec has 0157 octal.              (111,"a74")    <=> (0157, "a74") ,
            (112, "a203"),                      // for char 'p' using 112 as base10 equivalent (for C# source). Spec has 0160 octal.              (112,"a203")   <=> (0160, "a203"),
            (113, "a75"),                       // for char 'q' using 113 as base10 equivalent (for C# source). Spec has 0161 octal.              (113,"a75")    <=> (0161, "a75") ,
            (114, "a204"),                      // for char 'r' using 114 as base10 equivalent (for C# source). Spec has 0162 octal.              (114,"a204")   <=> (0162, "a204"),
            (115, "a76"),                       // for char 's' using 115 as base10 equivalent (for C# source). Spec has 0163 octal.              (115,"a76")    <=> (0163, "a76") ,
            (116, "a77"),                       // for char 't' using 116 as base10 equivalent (for C# source). Spec has 0164 octal.              (116,"a77")    <=> (0164, "a77") ,
            (117, "a78"),                       // for char 'u' using 117 as base10 equivalent (for C# source). Spec has 0165 octal.              (117,"a78")    <=> (0165, "a78") ,
            (118, "a79"),                       // for char 'v' using 118 as base10 equivalent (for C# source). Spec has 0166 octal.              (118,"a79")    <=> (0166, "a79") ,
            (119, "a81"),                       // for char 'w' using 119 as base10 equivalent (for C# source). Spec has 0167 octal.              (119,"a81")    <=> (0167, "a81") ,
            (120, "a82"),                       // for char 'x' using 120 as base10 equivalent (for C# source). Spec has 0170 octal.              (120,"a82")    <=> (0170, "a82") ,
            (121, "a83"),                       // for char 'y' using 121 as base10 equivalent (for C# source). Spec has 0171 octal.              (121,"a83")    <=> (0171, "a83") ,
            (122, "a84"),                       // for char 'z' using 122 as base10 equivalent (for C# source). Spec has 0172 octal.              (122,"a84")    <=> (0172, "a84") ,
            (123, "a97"),                       // for char '{' using 123 as base10 equivalent (for C# source). Spec has 0173 octal.              (123,"a97")    <=> (0173, "a97") ,
            (124, "a98"),                       // for char '|' using 124 as base10 equivalent (for C# source). Spec has 0174 octal.              (124,"a98")    <=> (0174, "a98") ,
            (125, "a99"),                       // for char '}' using 125 as base10 equivalent (for C# source). Spec has 0175 octal.              (125,"a99")    <=> (0175, "a99") ,
            (126, "a100"),                      // for char '~' using 126 as base10 equivalent (for C# source). Spec has 0176 octal.              (126,"a100")   <=> (0176, "a100"),
            (161, "a101"),                      // for char '¡' using 161 as base10 equivalent (for C# source). Spec has 0241 octal.              (161,"a101")   <=> (0241, "a101"),
            (162, "a102"),                      // for char '¢' using 162 as base10 equivalent (for C# source). Spec has 0242 octal.              (162,"a102")   <=> (0242, "a102"),
            (163, "a103"),                      // for char '£' using 163 as base10 equivalent (for C# source). Spec has 0243 octal.              (163,"a103")   <=> (0243, "a103"),
            (164, "a104"),                      // for char '¤' using 164 as base10 equivalent (for C# source). Spec has 0244 octal.              (164,"a104")   <=> (0244, "a104"),
            (165, "a106"),                      // for char '¥' using 165 as base10 equivalent (for C# source). Spec has 0245 octal.              (165,"a106")   <=> (0245, "a106"),
            (166, "a107"),                      // for char '¦' using 166 as base10 equivalent (for C# source). Spec has 0246 octal.              (166,"a107")   <=> (0246, "a107"),
            (167, "a108"),                      // for char '§' using 167 as base10 equivalent (for C# source). Spec has 0247 octal.              (167,"a108")   <=> (0247, "a108"),
            (168, "a112"),                      // for char '¨' using 168 as base10 equivalent (for C# source). Spec has 0250 octal.              (168,"a112")   <=> (0250, "a112"),
            (169, "a111"),                      // for char '©' using 169 as base10 equivalent (for C# source). Spec has 0251 octal.              (169,"a111")   <=> (0251, "a111"),
            (170, "a110"),                      // for char 'ª' using 170 as base10 equivalent (for C# source). Spec has 0252 octal.              (170,"a110")   <=> (0252, "a110"),
            (171, "a109"),                      // for char '«' using 171 as base10 equivalent (for C# source). Spec has 0253 octal.              (171,"a109")   <=> (0253, "a109"),
            (172, "a120"),                      // for char '¬' using 172 as base10 equivalent (for C# source). Spec has 0254 octal.              (172,"a120")   <=> (0254, "a120"),
            (173, "a121"),                      //              using 173 as base10 equivalent (for C# source). Spec has 0255 octal.              (173,"a121")   <=> (0255, "a121"),
            (174, "a122"),                      // for char '®' using 174 as base10 equivalent (for C# source). Spec has 0256 octal.              (174,"a122")   <=> (0256, "a122"),
            (175, "a123"),                      // for char '¯' using 175 as base10 equivalent (for C# source). Spec has 0257 octal.              (175,"a123")   <=> (0257, "a123"),
            (176, "a124"),                      // for char '°' using 176 as base10 equivalent (for C# source). Spec has 0260 octal.              (176,"a124")   <=> (0260, "a124"),
            (177, "a125"),                      // for char '±' using 177 as base10 equivalent (for C# source). Spec has 0261 octal.              (177,"a125")   <=> (0261, "a125"),
            (178, "a126"),                      // for char '²' using 178 as base10 equivalent (for C# source). Spec has 0262 octal.              (178,"a126")   <=> (0262, "a126"),
            (179, "a127"),                      // for char '³' using 179 as base10 equivalent (for C# source). Spec has 0263 octal.              (179,"a127")   <=> (0263, "a127"),
            (180, "a128"),                      // for char '´' using 180 as base10 equivalent (for C# source). Spec has 0264 octal.              (180,"a128")   <=> (0264, "a128"),
            (181, "a129"),                      // for char 'µ' using 181 as base10 equivalent (for C# source). Spec has 0265 octal.              (181,"a129")   <=> (0265, "a129"),
            (182, "a130"),                      // for char '¶' using 182 as base10 equivalent (for C# source). Spec has 0266 octal.              (182,"a130")   <=> (0266, "a130"),
            (183, "a131"),                      // for char '·' using 183 as base10 equivalent (for C# source). Spec has 0267 octal.              (183,"a131")   <=> (0267, "a131"),
            (184, "a132"),                      // for char '¸' using 184 as base10 equivalent (for C# source). Spec has 0270 octal.              (184,"a132")   <=> (0270, "a132"),
            (185, "a133"),                      // for char '¹' using 185 as base10 equivalent (for C# source). Spec has 0271 octal.              (185,"a133")   <=> (0271, "a133"),
            (186, "a134"),                      // for char 'º' using 186 as base10 equivalent (for C# source). Spec has 0272 octal.              (186,"a134")   <=> (0272, "a134"),
            (187, "a135"),                      // for char '»' using 187 as base10 equivalent (for C# source). Spec has 0273 octal.              (187,"a135")   <=> (0273, "a135"),
            (188, "a136"),                      // for char '¼' using 188 as base10 equivalent (for C# source). Spec has 0274 octal.              (188,"a136")   <=> (0274, "a136"),
            (189, "a137"),                      // for char '½' using 189 as base10 equivalent (for C# source). Spec has 0275 octal.              (189,"a137")   <=> (0275, "a137"),
            (190, "a138"),                      // for char '¾' using 190 as base10 equivalent (for C# source). Spec has 0276 octal.              (190,"a138")   <=> (0276, "a138"),
            (191, "a139"),                      // for char '¿' using 191 as base10 equivalent (for C# source). Spec has 0277 octal.              (191,"a139")   <=> (0277, "a139"),
            (192, "a140"),                      // for char 'À' using 192 as base10 equivalent (for C# source). Spec has 0300 octal.              (192,"a140")   <=> (0300, "a140"),
            (193, "a141"),                      // for char 'Á' using 193 as base10 equivalent (for C# source). Spec has 0301 octal.              (193,"a141")   <=> (0301, "a141"),
            (194, "a142"),                      // for char 'Â' using 194 as base10 equivalent (for C# source). Spec has 0302 octal.              (194,"a142")   <=> (0302, "a142"),
            (195, "a143"),                      // for char 'Ã' using 195 as base10 equivalent (for C# source). Spec has 0303 octal.              (195,"a143")   <=> (0303, "a143"),
            (196, "a144"),                      // for char 'Ä' using 196 as base10 equivalent (for C# source). Spec has 0304 octal.              (196,"a144")   <=> (0304, "a144"),
            (197, "a145"),                      // for char 'Å' using 197 as base10 equivalent (for C# source). Spec has 0305 octal.              (197,"a145")   <=> (0305, "a145"),
            (198, "a146"),                      // for char 'Æ' using 198 as base10 equivalent (for C# source). Spec has 0306 octal.              (198,"a146")   <=> (0306, "a146"),
            (199, "a147"),                      // for char 'Ç' using 199 as base10 equivalent (for C# source). Spec has 0307 octal.              (199,"a147")   <=> (0307, "a147"),
            (200, "a148"),                      // for char 'È' using 200 as base10 equivalent (for C# source). Spec has 0310 octal.              (200,"a148")   <=> (0310, "a148"),
            (201, "a149"),                      // for char 'É' using 201 as base10 equivalent (for C# source). Spec has 0311 octal.              (201,"a149")   <=> (0311, "a149"),
            (202, "a150"),                      // for char 'Ê' using 202 as base10 equivalent (for C# source). Spec has 0312 octal.              (202,"a150")   <=> (0312, "a150"),
            (203, "a151"),                      // for char 'Ë' using 203 as base10 equivalent (for C# source). Spec has 0313 octal.              (203,"a151")   <=> (0313, "a151"),
            (204, "a152"),                      // for char 'Ì' using 204 as base10 equivalent (for C# source). Spec has 0314 octal.              (204,"a152")   <=> (0314, "a152"),
            (205, "a153"),                      // for char 'Í' using 205 as base10 equivalent (for C# source). Spec has 0315 octal.              (205,"a153")   <=> (0315, "a153"),
            (206, "a154"),                      // for char 'Î' using 206 as base10 equivalent (for C# source). Spec has 0316 octal.              (206,"a154")   <=> (0316, "a154"),
            (207, "a155"),                      // for char 'Ï' using 207 as base10 equivalent (for C# source). Spec has 0317 octal.              (207,"a155")   <=> (0317, "a155"),
            (208, "a156"),                      // for char 'Ð' using 208 as base10 equivalent (for C# source). Spec has 0320 octal.              (208,"a156")   <=> (0320, "a156"),
            (209, "a157"),                      // for char 'Ñ' using 209 as base10 equivalent (for C# source). Spec has 0321 octal.              (209,"a157")   <=> (0321, "a157"),
            (210, "a158"),                      // for char 'Ò' using 210 as base10 equivalent (for C# source). Spec has 0322 octal.              (210,"a158")   <=> (0322, "a158"),
            (211, "a159"),                      // for char 'Ó' using 211 as base10 equivalent (for C# source). Spec has 0323 octal.              (211,"a159")   <=> (0323, "a159"),
            (212, "a160"),                      // for char 'Ô' using 212 as base10 equivalent (for C# source). Spec has 0324 octal.              (212,"a160")   <=> (0324, "a160"),
            (213, "a161"),                      // for char 'Õ' using 213 as base10 equivalent (for C# source). Spec has 0325 octal.              (213,"a161")   <=> (0325, "a161"),
            (214, "a163"),                      // for char 'Ö' using 214 as base10 equivalent (for C# source). Spec has 0326 octal.              (214,"a163")   <=> (0326, "a163"),
            (215, "a164"),                      // for char '×' using 215 as base10 equivalent (for C# source). Spec has 0327 octal.              (215,"a164")   <=> (0327, "a164"),
            (216, "a196"),                      // for char 'Ø' using 216 as base10 equivalent (for C# source). Spec has 0330 octal.              (216,"a196")   <=> (0330, "a196"),
            (217, "a165"),                      // for char 'Ù' using 217 as base10 equivalent (for C# source). Spec has 0331 octal.              (217,"a165")   <=> (0331, "a165"),
            (218, "a192"),                      // for char 'Ú' using 218 as base10 equivalent (for C# source). Spec has 0332 octal.              (218,"a192")   <=> (0332, "a192"),
            (219, "a166"),                      // for char 'Û' using 219 as base10 equivalent (for C# source). Spec has 0333 octal.              (219,"a166")   <=> (0333, "a166"),
            (220, "a167"),                      // for char 'Ü' using 220 as base10 equivalent (for C# source). Spec has 0334 octal.              (220,"a167")   <=> (0334, "a167"),
            (221, "a168"),                      // for char 'Ý' using 221 as base10 equivalent (for C# source). Spec has 0335 octal.              (221,"a168")   <=> (0335, "a168"),
            (222, "a169"),                      // for char 'Þ' using 222 as base10 equivalent (for C# source). Spec has 0336 octal.              (222,"a169")   <=> (0336, "a169"),
            (223, "a170"),                      // for char 'ß' using 223 as base10 equivalent (for C# source). Spec has 0337 octal.              (223,"a170")   <=> (0337, "a170"),
            (224, "a171"),                      // for char 'à' using 224 as base10 equivalent (for C# source). Spec has 0340 octal.              (224,"a171")   <=> (0340, "a171"),
            (225, "a172"),                      // for char 'á' using 225 as base10 equivalent (for C# source). Spec has 0341 octal.              (225,"a172")   <=> (0341, "a172"),
            (226, "a173"),                      // for char 'â' using 226 as base10 equivalent (for C# source). Spec has 0342 octal.              (226,"a173")   <=> (0342, "a173"),
            (227, "a162"),                      // for char 'ã' using 227 as base10 equivalent (for C# source). Spec has 0343 octal.              (227,"a162")   <=> (0343, "a162"),
            (228, "a174"),                      // for char 'ä' using 228 as base10 equivalent (for C# source). Spec has 0344 octal.              (228,"a174")   <=> (0344, "a174"),
            (229, "a175"),                      // for char 'å' using 229 as base10 equivalent (for C# source). Spec has 0345 octal.              (229,"a175")   <=> (0345, "a175"),
            (230, "a176"),                      // for char 'æ' using 230 as base10 equivalent (for C# source). Spec has 0346 octal.              (230,"a176")   <=> (0346, "a176"),
            (231, "a177"),                      // for char 'ç' using 231 as base10 equivalent (for C# source). Spec has 0347 octal.              (231,"a177")   <=> (0347, "a177"),
            (232, "a178"),                      // for char 'è' using 232 as base10 equivalent (for C# source). Spec has 0350 octal.              (232,"a178")   <=> (0350, "a178"),
            (233, "a179"),                      // for char 'é' using 233 as base10 equivalent (for C# source). Spec has 0351 octal.              (233,"a179")   <=> (0351, "a179"),
            (234, "a193"),                      // for char 'ê' using 234 as base10 equivalent (for C# source). Spec has 0352 octal.              (234,"a193")   <=> (0352, "a193"),
            (235, "a180"),                      // for char 'ë' using 235 as base10 equivalent (for C# source). Spec has 0353 octal.              (235,"a180")   <=> (0353, "a180"),
            (236, "a199"),                      // for char 'ì' using 236 as base10 equivalent (for C# source). Spec has 0354 octal.              (236,"a199")   <=> (0354, "a199"),
            (237, "a181"),                      // for char 'í' using 237 as base10 equivalent (for C# source). Spec has 0355 octal.              (237,"a181")   <=> (0355, "a181"),
            (238, "a200"),                      // for char 'î' using 238 as base10 equivalent (for C# source). Spec has 0356 octal.              (238,"a200")   <=> (0356, "a200"),
            (239, "a182"),                      // for char 'ï' using 239 as base10 equivalent (for C# source). Spec has 0357 octal.              (239,"a182")   <=> (0357, "a182"),
            (241, "a201"),                      // for char 'ñ' using 241 as base10 equivalent (for C# source). Spec has 0361 octal.              (241,"a201")   <=> (0361, "a201"),
            (242, "a183"),                      // for char 'ò' using 242 as base10 equivalent (for C# source). Spec has 0362 octal.              (242,"a183")   <=> (0362, "a183"),
            (243, "a184"),                      // for char 'ó' using 243 as base10 equivalent (for C# source). Spec has 0363 octal.              (243,"a184")   <=> (0363, "a184"),
            (244, "a197"),                      // for char 'ô' using 244 as base10 equivalent (for C# source). Spec has 0364 octal.              (244,"a197")   <=> (0364, "a197"),
            (245, "a185"),                      // for char 'õ' using 245 as base10 equivalent (for C# source). Spec has 0365 octal.              (245,"a185")   <=> (0365, "a185"),
            (246, "a194"),                      // for char 'ö' using 246 as base10 equivalent (for C# source). Spec has 0366 octal.              (246,"a194")   <=> (0366, "a194"),
            (247, "a198"),                      // for char '÷' using 247 as base10 equivalent (for C# source). Spec has 0367 octal.              (247,"a198")   <=> (0367, "a198"),
            (248, "a186"),                      // for char 'ø' using 248 as base10 equivalent (for C# source). Spec has 0370 octal.              (248,"a186")   <=> (0370, "a186"),
            (249, "a195"),                      // for char 'ù' using 249 as base10 equivalent (for C# source). Spec has 0371 octal.              (249,"a195")   <=> (0371, "a195"),
            (250, "a187"),                      // for char 'ú' using 250 as base10 equivalent (for C# source). Spec has 0372 octal.              (250,"a187")   <=> (0372, "a187"),
            (251, "a188"),                      // for char 'û' using 251 as base10 equivalent (for C# source). Spec has 0373 octal.              (251,"a188")   <=> (0373, "a188"),
            (252, "a189"),                      // for char 'ü' using 252 as base10 equivalent (for C# source). Spec has 0374 octal.              (252,"a189")   <=> (0374, "a189"),
            (253, "a190"),                      // for char 'ý' using 253 as base10 equivalent (for C# source). Spec has 0375 octal.              (253,"a190")   <=> (0375, "a190"),
            (254, "a191")                       // for char 'þ' using 254 as base10 equivalent (for C# source). Spec has 0376 octal.              (254,"a191")   <=> (0376, "a191")
        };

        /// <summary>
        /// Single instance of this encoding.
        /// </summary>
        public static ZapfDingbatsEncoding Instance { get; } = new ZapfDingbatsEncoding();

        /// <inheritdoc />
        public override string EncodingName => "ZapfDingbatsEncoding";

        private ZapfDingbatsEncoding()
        {
            foreach ((var code, var name) in EncodingTable)
            {
                // Note: code from source is already base 10 no need to use OctalHelpers.FromOctalInt
                Add(code, name);
            }
        }
    }
}
